package com.ruoyi.demo.service.impl;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.ruoyi.demo.dto.TaskDataDto;
import com.ruoyi.demo.mapper.ProTaskSnDataMapper;
import com.ruoyi.demo.service.IMesBindTaskStationService;
import com.ruoyi.demo.vo.*;
import com.ruoyi.system.service.ISysConfigService;
import lombok.Data;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.demo.mapper.MesBindTaskDataMapper;
import com.ruoyi.demo.domain.MesBindTaskData;
import com.ruoyi.demo.service.IMesBindTaskDataService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 任务单记录数据Service业务层处理
 *
 * @author shc
 * @date 2024-12-12
 */
@Service
public class MesBindTaskDataServiceImpl extends ServiceImpl<MesBindTaskDataMapper, MesBindTaskData> implements IMesBindTaskDataService {
    @Autowired
    private MesBindTaskDataMapper mesBindTaskDataMapper;
    @Autowired
    private ISysConfigService configService;
    @Autowired
    private IMesBindTaskStationService mesBindTaskStationService;
    @Autowired
    private ProTaskSnDataMapper proTaskSnDataMapper;
    private static final Logger logger = LoggerFactory.getLogger(ServiceImpl.class);

    /**
     * 查询任务单记录数据列表
     *
     * @param mesBindTaskData 任务单记录数据
     * @return 任务单记录数据
     */
    @Override
    public List<MesBindTaskData> selectMesBindTaskDataList(MesBindTaskData mesBindTaskData) {
        LambdaQueryWrapper<MesBindTaskData> queryWrapper = Wrappers.lambdaQuery();
        if (StringUtils.isNotEmpty(mesBindTaskData.getProduct())) {
            queryWrapper.eq(MesBindTaskData::getProduct, mesBindTaskData.getProduct());
        }
        if (StringUtils.isNotEmpty(mesBindTaskData.getLine())) {
            queryWrapper.eq(MesBindTaskData::getLine, mesBindTaskData.getLine());
        }
        if (StringUtils.isNotEmpty(mesBindTaskData.getStation())) {
            queryWrapper.eq(MesBindTaskData::getStation, mesBindTaskData.getStation());
        }
        if (StringUtils.isNotEmpty(mesBindTaskData.getMo())) {
            queryWrapper.eq(MesBindTaskData::getMo, mesBindTaskData.getMo());
        }
        if (StringUtils.isNotEmpty(mesBindTaskData.getMtm())) {
            queryWrapper.eq(MesBindTaskData::getMtm, mesBindTaskData.getMtm());
        }
        if (StringUtils.isNotEmpty(mesBindTaskData.getTaskCode())) {
            queryWrapper.eq(MesBindTaskData::getTaskCode, mesBindTaskData.getTaskCode());
        }
        if (StringUtils.isNotEmpty(mesBindTaskData.getWorkbenchNo())) {
            queryWrapper.eq(MesBindTaskData::getWorkbenchNo, mesBindTaskData.getWorkbenchNo());
        }
        if (StringUtils.isNotNull(mesBindTaskData.getFormId())) {
            queryWrapper.eq(MesBindTaskData::getFormId, mesBindTaskData.getFormId());
        }
        if (StringUtils.isNotEmpty(mesBindTaskData.getFormType())) {
            queryWrapper.eq(MesBindTaskData::getFormType, mesBindTaskData.getFormType());
        }
        if (StringUtils.isNotEmpty(mesBindTaskData.getType())) {
            queryWrapper.eq(MesBindTaskData::getType, mesBindTaskData.getType());
        }
        if (StringUtils.isNotNull(mesBindTaskData.getGroupId())) {
            queryWrapper.eq(MesBindTaskData::getGroupId, mesBindTaskData.getGroupId());
        }
        if (StringUtils.isNotEmpty(mesBindTaskData.getLabel())) {
            queryWrapper.eq(MesBindTaskData::getLabel, mesBindTaskData.getLabel());
        }
        if (StringUtils.isNotEmpty(mesBindTaskData.getName())) {
            queryWrapper.like(MesBindTaskData::getName, mesBindTaskData.getName());
        }
        if (StringUtils.isNotEmpty(mesBindTaskData.getValue())) {
            queryWrapper.eq(MesBindTaskData::getValue, mesBindTaskData.getValue());
        }
        if (StringUtils.isNotEmpty(mesBindTaskData.getPn())) {
            queryWrapper.eq(MesBindTaskData::getPn, mesBindTaskData.getPn());
        }
        if (StringUtils.isNotEmpty(mesBindTaskData.getPnClass())) {
            queryWrapper.eq(MesBindTaskData::getPnClass, mesBindTaskData.getPnClass());
        }
        if (StringUtils.isNotNull(mesBindTaskData.getPnQty())) {
            queryWrapper.eq(MesBindTaskData::getPnQty, mesBindTaskData.getPnQty());
        }
        if (StringUtils.isNotNull(mesBindTaskData.getScrap())) {
            queryWrapper.eq(MesBindTaskData::getScrap, mesBindTaskData.getScrap());
        }
        if (StringUtils.isNotEmpty(mesBindTaskData.getNgValue())) {
            queryWrapper.eq(MesBindTaskData::getNgValue, mesBindTaskData.getNgValue());
        }
        if (StringUtils.isNotNull(mesBindTaskData.getVersion())) {
            queryWrapper.eq(MesBindTaskData::getVersion, mesBindTaskData.getVersion());
        }
        return mesBindTaskDataMapper.selectList(queryWrapper);
    }

    @Override
    public List<TaskDataVo> getSnRank(TaskDataDto taskDataDto) {
        //查询一厂mes逻辑
        if (taskDataDto.getType() != null && taskDataDto.getType().equals("GR")) {
//            List<SnPrintDataVo> taskDataVos = proTaskSnDataMapper.getZhongceData(taskDataDto);
            Map<String, SnPrintDataVo> taskDataVoMap = proTaskSnDataMapper.getZhongceData(taskDataDto).stream().collect(Collectors.toMap(SnPrintDataVo::getTaskSn, Function.identity(), (oldVal, newVal) -> newVal));
            List<SnPrintDataVo> taskDataVos = new ArrayList<>(taskDataVoMap.values());
            return taskDataVos.stream().map(this::getGrRankInfo).collect(Collectors.toList());
        } else {
            List<SnStationVo> snStationVos = mesBindTaskStationService.selectBindTaskStationDataList(taskDataDto);
            System.out.println(snStationVos);
            return snStationVos.stream().map(this::getRankInfo).collect(Collectors.toList());
        }


    }

    private TaskDataVo getGrRankInfo(SnPrintDataVo snPrintDataVo) {
        TaskDataVo taskDataVo = new TaskDataVo();
        taskDataVo.setSn(snPrintDataVo.getTaskSn());
        try {
            ObjectMapper objectMapper = new ObjectMapper();
            taskDataVo.setProductType(snPrintDataVo.getItemCode());
            String formData = snPrintDataVo.getFormData();
            if (formData == null || formData.trim().isEmpty()) {
                // 处理空字符串情况
                taskDataVo.setPower(null);

            } else {
                // 2. 解析JSON字符串为JsonNode
                JsonNode jsonNode = objectMapper.readTree(formData);

                // 3. 提取power1的值（注意：JSON中power1是字符串类型，直接获取文本）
                String power = jsonNode.get("power1") != null ? jsonNode.get("power1").asText() : null;
                taskDataVo.setPower(power);
                taskDataVo.setStatus("G");
                if (power == null) {
                    taskDataVo.setRank("N");
                    taskDataVo.setStatus("NG");
                    taskDataVo.setMsg("功率为空");
                } else if (Double.parseDouble(power) >= 4350) {
                    taskDataVo.setRank("A");
                } else if (Double.parseDouble(power) < 4350 && Double.parseDouble(power) > 4200) {
                    taskDataVo.setRank("B");
                } else if (Double.parseDouble(power) < 4200) {
                    taskDataVo.setRank("C");
                }
            }

            return taskDataVo;
        } catch (Exception e) {
            logger.error("失败,msg={}", e.getMessage());
            e.printStackTrace();
            taskDataVo.setRank("N");
            taskDataVo.setStatus("NG");
            taskDataVo.setMsg("失败," + e.getMessage());
            taskDataVo.setStatus("ERROR");
            return taskDataVo;
        }
    }

    private TaskDataVo getRankInfo(SnStationVo snStationVo) {
        TaskDataVo taskDataVo = new TaskDataVo();
        taskDataVo.setSn(snStationVo.getTaskCode());
        try {
            taskDataVo.setProductType(snStationVo.getModel());
            String model = snStationVo.getModel();
            String power = snStationVo.getPower1();
            taskDataVo.setPower(power);
            taskDataVo.setStatus("G");
            String byGcpsValue = snStationVo.getByGcps();
            if (byGcpsValue == null) {
                // 如果值为 null，则设置为 "N"
                taskDataVo.setByGcps("N");
            } else if ("Y".equals(byGcpsValue)) {
                // 如果值不是 "Y"，可以根据需要进行其他处理
                // 这里可以添加额外的逻辑
                taskDataVo.setByGcps("Y");
            } else {
                taskDataVo.setByGcps("N");
            }
            //todo NP120-3300
            if (model.contains("NP52-CW15")) {
                if (Double.parseDouble(power) >= 1650) {
                    taskDataVo.setRank("A");
                } else if (Double.parseDouble(power) >= 1550 && Double.parseDouble(power) < 1650) {
                    taskDataVo.setRank("B");
                } else {
                    taskDataVo.setRank("N");
                    taskDataVo.setStatus("NG");
                }
            } else if (model.contains("NP76-1500T")) {
                if (Double.parseDouble(power) >= 2000) {
                    taskDataVo.setRank("A");
                } else if (Double.parseDouble(power) >= 1900 && Double.parseDouble(power) < 2000) {
                    taskDataVo.setRank("B");
                } else {
                    taskDataVo.setRank("N");
                    taskDataVo.setStatus("NG");
                }
            } else if (model.contains("NP76-CW20")) {
                if (Double.parseDouble(power) >= 2500) {
                    taskDataVo.setRank("A");
                } else if (Double.parseDouble(power) >= 2400 && Double.parseDouble(power) < 2500) {
                    taskDataVo.setRank("B");
                } else {
                    taskDataVo.setRank("N");
                    taskDataVo.setStatus("NG");
                }
            } else if (model.contains("NP120-3300T")) {
                if (Double.parseDouble(power) >= 4100) {
                    taskDataVo.setRank("A");
                } else if (Double.parseDouble(power) >= 4000 && Double.parseDouble(power) < 4100) {
                    taskDataVo.setRank("B");
                } else {
                    taskDataVo.setRank("N");
                    taskDataVo.setStatus("NG");
                }
            } else {
                taskDataVo.setRank("N");
                taskDataVo.setMsg("规定型号之外");
                taskDataVo.setMsg(snStationVo.getTaskCode() + "的型号不在分档型号内");
                taskDataVo.setStatus("NG");
                return taskDataVo;
            }
            return taskDataVo;
        } catch (Exception e) {
            logger.error("失败,msg={}", e.getMessage());
            e.printStackTrace();
            taskDataVo.setRank("N");
            taskDataVo.setStatus("NG");
            taskDataVo.setMsg("失败," + e.getMessage());
            taskDataVo.setStatus("ERROR");
            return taskDataVo;
        }

    }

    //	private TaskDataVo getRankInfo(String taskCode) {
//		TaskDataVo taskDataVo = new TaskDataVo();
//		taskDataVo.setSn(taskCode);
//		try {
//
////			String url = configService.selectConfigByKey("mes.url");
//			String url="http://192.168.80.180/prod-api/basicData/open-api/getProductionData?key=MES_BY_DATA&sn="+taskCode;
//			if (StringUtils.isEmpty(url)) {
////				throw new ServiceException("请配置获取地址参数");
//				taskDataVo.setMsg("请配置获取地址参数");
//				taskDataVo.setStatus("ERROR");
//				return taskDataVo;
//			}
//			Map<String, Object> map = new HashMap();
//			HttpResponse execute = HttpUtil.createGet(url).execute();
//			if (!execute.isOk()) {
//				logger.error("请求失败,body={},execute={}", execute.body(), execute);
////				throw new RuntimeException(execute.body());
//				taskDataVo.setMsg("请求失败,body="+execute.body()+","+execute);
//				taskDataVo.setStatus("ERROR");
//				return taskDataVo;
//			}
//			String res = UnicodeUtil.toString(execute.body());
//			System.out.println(res);
//			cn.hutool.json.JSONObject jsonObject = JSONUtil.parseObj(res, true);
//			AuthTokenResResult resultObj = jsonObject.toBean(AuthTokenResResult.class, true);
//			System.out.println(jsonObject);
//			logger.info("inventorys,resultObj={}", resultObj);
//			if (resultObj.getCode() != 200) {
//				taskDataVo.setMsg("获取sn数据失败,code=" + resultObj.getCode() + ",msg=" + resultObj.getMsg()+taskCode);
//				logger.error("获取数据失败,code={},msg={},result={}", resultObj.getCode(), resultObj.getMsg(), resultObj);
////				throw new RuntimeException("获取sn数据失败,code=" + resultObj.getCode() + ",msg=" + resultObj.getMsg()+taskCode);
//				taskDataVo.setStatus("ERROR");
//				return taskDataVo;
//			}
//
//			if (resultObj.getData() == null) {
//				taskDataVo.setMsg("获取数据失败请手动处理,code=" + resultObj.getCode() + ",msg=" + resultObj.getMsg());
//				logger.error("获取数据失败请手动处理,code={},msg={},result={}", resultObj.getCode(), resultObj.getMsg(), resultObj);
////				throw new RuntimeException("获取数据失败请手动处理,code=" + resultObj.getCode() + ",msg=" + resultObj.getMsg());
//			}
//			List<SnDataVo> snDataVoList = resultObj.getData();
//
//			//产品型号
//			if (snDataVoList==null){
////				throw new RuntimeException("sn"+taskCode+"信息不存在");
//				taskDataVo.setMsg("sn"+taskCode+"信息不存在");
//				taskDataVo.setStatus("ERROR");
//				return taskDataVo;
//			}
//			String snMiniType=snDataVoList.get(0).getSUPER_PRODUCT_TYPE();
//			taskDataVo.setProductType(snMiniType);
//
//			QueryWrapper<MesBindTaskData> mesBindTaskDataEpQueryWrapper = new QueryWrapper<>();
//			mesBindTaskDataEpQueryWrapper.eq("task_code",taskCode).eq("name","EP").eq("del_flag",0).eq("product","BY")
//					.eq("station","终测");
//			MesBindTaskData mesBindTaskData = mesBindTaskDataMapper.selectOne(mesBindTaskDataEpQueryWrapper);
//			if (mesBindTaskData==null){
////				throw new RuntimeException(taskCode+"终测信息Ep不存在");
//				taskDataVo.setMsg(taskCode+"终测信息Ep不存在");
//				taskDataVo.setStatus("ERROR");
//				return taskDataVo;
//			}
//			//ep
//			String ep=mesBindTaskData.getValue();
//			taskDataVo.setEp(ep);
//			//根据型号和ep判断ab档
//			//todo NP120-3300
//			if(snMiniType.contains("NP120-3300")){
//				//获取终测功率
//				QueryWrapper<MesBindTaskData> mesBindTaskDataPowerQueryWrapper = new QueryWrapper<>();
//				mesBindTaskDataPowerQueryWrapper.eq("task_code",taskCode).eq("name","power1").eq("del_flag",0).eq("product","BY")
//						.eq("station","终测");
//				MesBindTaskData mesBindTaskDataPower = mesBindTaskDataMapper.selectOne(mesBindTaskDataPowerQueryWrapper);
//				//整泵功率
//				String power=mesBindTaskDataPower.getValue();
//				taskDataVo.setEp(ep);
//				taskDataVo.setPower(power);
//				//判定NP120-3300型号的如果EP>=43%,4000W≤终测功率＜4200W,则为B，终测功率>=4200w则为A
//				taskDataVo.setStatus("G");
//				if (Double.parseDouble(power)>=4000&&Double.parseDouble(power)<4200){
//					taskDataVo.setRank("B");
//					taskDataVo.setRankType("DQ");
//				}else if(Double.parseDouble(power)>=4200){
//
//					if(Double.parseDouble(ep)>=45){
//						taskDataVo.setRankType("HS");
//						taskDataVo.setRank("A");
//					}else if(Double.parseDouble(ep)>=43&&Double.parseDouble(ep)<45){
//						taskDataVo.setRankType("DQ");
//						taskDataVo.setRank("A");
//					}else{
//						taskDataVo.setMsg("EP"+ep+"不满足条件");
//						taskDataVo.setStatus("NG");
//					}
//				}else{
//					taskDataVo.setMsg("功率"+power+"不满足条件");
//					taskDataVo.setStatus("NG");
//				}
//			}else if (snMiniType.contains("NP120-CW30")){
//				taskDataVo.setStatus("G");
//				if(Double.parseDouble(ep)>=45){
//					taskDataVo.setRankType("DQ");
//					taskDataVo.setRank("A");
//				}else if(Double.parseDouble(ep)>=43&&Double.parseDouble(ep)<45){
//					taskDataVo.setRankType("DQ");
//					taskDataVo.setRank("B");
//				}else{
//					taskDataVo.setMsg("EP"+ep+"不满足条件");
//					taskDataVo.setStatus("NG");
//				}
//			}else if (snMiniType.contains("NP52")||snMiniType.contains("NP76")){
//				taskDataVo.setStatus("G");
//				if(Double.parseDouble(ep)>=43){
//					taskDataVo.setRankType("DQ");
//					taskDataVo.setRank("A");
//				}else if(Double.parseDouble(ep)>=41&&Double.parseDouble(ep)<43){
//					taskDataVo.setRankType("DQ");
//					taskDataVo.setRank("B");
//				}else{
//					taskDataVo.setMsg("EP"+ep+"不满足条件");
//					taskDataVo.setStatus("NG");
//				}
//			}else{
//				taskDataVo.setMsg("规定型号之外");
//				taskDataVo.setMsg(taskCode+"的型号不在分档型号内");
//				taskDataVo.setStatus("NG");
//				return taskDataVo;
//			}
//			return taskDataVo;
//		} catch (Exception e) {
//			logger.error("失败,msg={}", e.getMessage());
//			e.printStackTrace();
////			throw new RuntimeException(e.getMessage());
//			taskDataVo.setMsg("失败,"+e.getMessage());
//			taskDataVo.setStatus("ERROR");
//			return taskDataVo;
//		}
//
//	}
    @Data
    public class AuthTokenResResult {

        private int code;

        private String msg;

        private List<SnDataVo> data;

        private long count;
    }
    @Override
    public List<SnWareHouseDataVo> selectSnWareHouseList() {
        return mesBindTaskDataMapper.selectSnWareHouseList();
    }
}
